//
// "$Id: fl_font_mac.cxx 10193 2014-06-14 11:06:42Z manolo $"
//
// MacOS font selection routines for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2011 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     http://www.fltk.org/COPYING.php
//
// Please report all bugs and problems on the following page:
//
//     http://www.fltk.org/str.php
//

#include "fltk_config.h"
#if __FLTK_MACOSX__
#include <math.h>

Fl_Fontdesc* fl_fonts = NULL;

/* from fl_utf.c */
extern unsigned fl_utf8toUtf16(const char* src, unsigned srclen, unsigned short* dst, unsigned dstlen);

static CGAffineTransform font_mx = { 1, 0, 0, -1, 0, 0 };
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
static CFMutableDictionaryRef attributes = NULL;
#endif

const int Fl_X::CoreText_threshold = 100500; // this represents Mac OS 10.5
// condition when the ATSU API is available at compile time
#define HAS_ATSU (!__LP64__) && MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_11

Fl_Font_Descriptor::Fl_Font_Descriptor(const char* name, Fl_Fontsize Size)
{
	next = 0;
#  if HAVE_GL
	listbase = 0;
#  endif

//  knowWidths = 0;
	// OpenGL needs those for its font handling
	size = Size;
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
		CFStringRef str = CFStringCreateWithCString(NULL, name, kCFStringEncodingUTF8);
		fontref = CTFontCreateWithName(str, size, NULL);
		CGGlyph glyph[2];
		const UniChar A[2]= {'W','.'};
		CTFontGetGlyphsForCharacters(fontref, A, glyph, 2);
		CGSize advances[2];
		double w;
		CTFontGetAdvancesForGlyphs(fontref, kCTFontHorizontalOrientation, glyph, advances, 2);
		w = advances[0].width;
		if ( fabs(advances[0].width - advances[1].width) < 1E-2 ) {//this is a fixed-width font
			// slightly rescale fixed-width fonts so the character width has an integral value
			CFRelease(fontref);
			CGFloat fsize = size / ( w/floor(w + 0.5) );
			fontref = CTFontCreateWithName(str, fsize, NULL);
			w = CTFontGetAdvancesForGlyphs(fontref, kCTFontHorizontalOrientation, glyph, NULL, 1);
		}
		CFRelease(str);
		ascent = (short)(CTFontGetAscent(fontref) + 0.5);
		descent = (short)(CTFontGetDescent(fontref) + 0.5);
		q_width = w + 0.5;
		for (unsigned i = 0; i < sizeof(width)/sizeof(float*); i++) width[i] = NULL;
		if (!attributes) {
			static CFNumberRef zero_ref;
			float zero = 0.;
			zero_ref = CFNumberCreate(NULL, kCFNumberFloat32Type, &zero);
			// deactivate kerning for all fonts, so that string width = sum of character widths
			// which allows fast fl_width() implementation.
			attributes = CFDictionaryCreateMutable(kCFAllocatorDefault,
			                                       3,
			                                       &kCFTypeDictionaryKeyCallBacks,
			                                       &kCFTypeDictionaryValueCallBacks);
			CFDictionarySetValue (attributes, kCTKernAttributeName, zero_ref);
		}
		if (ascent == 0) { // this may happen with some third party fonts
			CFDictionarySetValue (attributes, kCTFontAttributeName, fontref);
			CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, CFSTR("Wj"), attributes);
			CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
			CFRelease(mastr);
			CGFloat fascent, fdescent;
			CTLineGetTypographicBounds(ctline, &fascent, &fdescent, NULL);
			CFRelease(ctline);
			ascent = (short)(fascent + 0.5);
			descent = (short)(fdescent + 0.5);
		}
	} else {
#endif
#if HAS_ATSU
		OSStatus err;
		// fill our structure with a few default values
		ascent = Size*3/4.;
		descent = Size-ascent;
		q_width = Size*2/3.;
		// now we allocate everything needed to render text in this font later
		// get us the default layout and style
		err = ATSUCreateTextLayout(&layout);
		UniChar mTxt[2] = { 65, 0 };
		err = ATSUSetTextPointerLocation(layout, mTxt, kATSUFromTextBeginning, 1, 1);
		err = ATSUCreateStyle(&style);
		err = ATSUSetRunStyle(layout, style, kATSUFromTextBeginning, kATSUToTextEnd);
		// now set the actual font, size and attributes. We also set the font matrix to
		// render our font up-side-down, so when rendered through our inverted CGContext,
		// text will appear normal again.
		Fixed fsize = IntToFixed(Size);
		ATSUFontID fontID;
		ATSUFindFontFromName(name, strlen(name), kFontFullName, kFontMacintoshPlatform, kFontNoScriptCode, kFontEnglishLanguage, &fontID);

		// draw the font upside-down... Compensate for fltk/OSX origin differences
		ATSUAttributeTag sTag[] = { kATSUFontTag, kATSUSizeTag, kATSUFontMatrixTag };
		ByteCount sBytes[] = { sizeof(ATSUFontID), sizeof(Fixed), sizeof(CGAffineTransform) };
		ATSUAttributeValuePtr sAttr[] = { &fontID, &fsize, &font_mx };
		if (fontID != kATSUInvalidFontID) err = ATSUSetAttributes(style, 1, sTag, sBytes, sAttr); // set the font attribute
		err = ATSUSetAttributes(style, 2, sTag + 1, sBytes + 1, sAttr + 1); // then the size and matrix attributes
		// next, make sure that Quartz will only render at integer coordinates
		ATSLineLayoutOptions llo = kATSLineUseDeviceMetrics | kATSLineDisableAllLayoutOperations;
		ATSUAttributeTag aTag[] = { kATSULineLayoutOptionsTag };
		ByteCount aBytes[] = { sizeof(ATSLineLayoutOptions) };
		ATSUAttributeValuePtr aAttr[] = { &llo };
		err = ATSUSetLineControls (layout, kATSUFromTextBeginning, 1, aTag, aBytes, aAttr);
		// now we are finally ready to measure some letter to get the bounding box
		Fixed bBefore, bAfter, bAscent, bDescent;
		err = ATSUGetUnjustifiedBounds(layout, kATSUFromTextBeginning, 1, &bBefore, &bAfter, &bAscent, &bDescent);
		// Requesting a certain height font on Mac does not guarantee that ascent+descent
		// equal the requested height. fl_height will reflect the actual height that we got.
		// The font "Apple Chancery" is a pretty extreme example of overlapping letters.
		float fa = -FixedToFloat(bAscent), fd = -FixedToFloat(bDescent);
		if (fa>0.0f && fd>0.0f) {
			//float f = Size/(fa+fd);
			ascent = int(fa); //int(fa*f+0.5f);
			descent = int(fd); //Size - ascent;
		}
		int w = FixedToInt(bAfter);
		if (w)
			q_width = FixedToInt(bAfter);

# define ENABLE_TRANSIENT_FONTS  1

# ifdef ENABLE_TRANSIENT_FONTS
		// Now, by way of experiment, try enabling Transient Font Matching, this will
		// cause ATSU to find a suitable font to render any chars the current font can't do...
		ATSUSetTransientFontMatching (layout, true);
# endif
#endif//HAS_ATSU
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	}
#endif
}

Fl_Font_Descriptor::~Fl_Font_Descriptor()
{
	/*
	#if HAVE_GL
	 // ++ todo: remove OpenGL font alocations
	// Delete list created by gl_draw().  This is not done by this code
	// as it will link in GL unnecessarily.  There should be some kind
	// of "free" routine pointer, or a subclass?
	// if (listbase) {
	//  int base = font->min_char_or_byte2;
	//  int size = font->max_char_or_byte2-base+1;
	//  int base = 0; int size = 256;
	//  glDeleteLists(listbase+base,size);
	// }
	#endif
	  */
	if (this == fl_graphics_driver->font_descriptor()) fl_graphics_driver->font_descriptor(NULL);
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	if (fl_mac_os_version >= Fl_X::CoreText_threshold)  {
		CFRelease(fontref);
		for (unsigned i = 0; i < sizeof(width)/sizeof(float*); i++) {
			if (width[i]) free(width[i]);
		}
	}
#endif
}

////////////////////////////////////////////////////////////////

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
static Fl_Fontdesc built_in_table_PS[] = { // PostScript font names preferred when Mac OS 鈮?10.5
	{"ArialMT"},
	{"Arial-BoldMT"},
	{"Arial-ItalicMT"},
	{"Arial-BoldItalicMT"},
	{"Courier"},
	{"Courier-Bold"},
	{"Courier-Oblique"},
	{"Courier-BoldOblique"},
	{"TimesNewRomanPSMT"},
	{"TimesNewRomanPS-BoldMT"},
	{"TimesNewRomanPS-ItalicMT"},
	{"TimesNewRomanPS-BoldItalicMT"},
	{"Symbol"},
	{"Monaco"},
	{"AndaleMono"}, // there is no bold Monaco font on standard Mac
	{"ZapfDingbatsITC"}
};
#endif

static Fl_Fontdesc built_in_table_full[] = { // full font names used before 10.5
	{"Arial"},
	{"Arial Bold"},
	{"Arial Italic"},
	{"Arial Bold Italic"},
	{"Courier"},
	{"Courier Bold"},
	{"Courier New Italic"},
	{"Courier New Bold Italic"},
	{"Times New Roman"},
	{"Times New Roman Bold"},
	{"Times New Roman Italic"},
	{"Times New Roman Bold Italic"},
	{"Symbol"},
	{"Monaco"},
	{"Andale Mono"}, // there is no bold Monaco font on standard Mac
	{"Webdings"}
};

static UniChar *utfWbuf = 0;
static unsigned utfWlen = 0;

static UniChar *mac_Utf8_to_Utf16(const char *txt, int len, int *new_len)
{
	unsigned wlen = fl_utf8toUtf16(txt, len, (unsigned short*)utfWbuf, utfWlen);
	if (wlen >= utfWlen) {
		utfWlen = wlen + 100;
		if (utfWbuf) free(utfWbuf);
		utfWbuf = (UniChar*)malloc((utfWlen)*sizeof(UniChar));
		wlen = fl_utf8toUtf16(txt, len, (unsigned short*)utfWbuf, utfWlen);
	}
	*new_len = wlen;
	return utfWbuf;
} // mac_Utf8_to_Utf16

Fl_Fontdesc* Fl_X::calc_fl_fonts(void)
{
	if (!fl_mac_os_version) fl_mac_os_version = calc_mac_os_version();
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	return (fl_mac_os_version >= Fl_X::CoreText_threshold ? built_in_table_PS : built_in_table_full);
#else
	return built_in_table_full;
#endif
}

static Fl_Font_Descriptor* find(Fl_Font fnum, Fl_Fontsize size)
{
	if (!fl_fonts) fl_fonts = Fl_X::calc_fl_fonts();
	Fl_Fontdesc* s = fl_fonts+fnum;
	if (!s->name) s = fl_fonts; // use 0 if fnum undefined
	Fl_Font_Descriptor* f;
	for (f = s->first; f; f = f->next)
		if (f->size == size) return f;
	f = new Fl_Font_Descriptor(s->name, size);
	f->next = s->first;
	s->first = f;
	return f;
}

////////////////////////////////////////////////////////////////
// Public interface:

void Fl_Quartz_Graphics_Driver::font(Fl_Font fnum, Fl_Fontsize size)
{
	if (fnum==-1) {
		Fl_Graphics_Driver::font(0, 0);
		return;
	}
	Fl_Graphics_Driver::font(fnum, size);
	this->font_descriptor( find(fnum, size) );
}

int Fl_Quartz_Graphics_Driver::height()
{
	if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
	Fl_Font_Descriptor *fl_fontsize = font_descriptor();
	return fl_fontsize->ascent + fl_fontsize->descent;
}

int Fl_Quartz_Graphics_Driver::descent()
{
	if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
	Fl_Font_Descriptor *fl_fontsize = font_descriptor();
	return fl_fontsize->descent+1;
}

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
// returns width of a pair of UniChar's in the surrogate range
static CGFloat surrogate_width(const UniChar *txt, Fl_Font_Descriptor *fl_fontsize)
{
	CTFontRef font2 = fl_fontsize->fontref;
	bool must_release = false;
	CGGlyph glyphs[2];
	bool b = CTFontGetGlyphsForCharacters(font2, txt, glyphs, 2);
	CGSize a;
	if(!b) { // the current font doesn't contain this char
		CFStringRef str = CFStringCreateWithCharactersNoCopy(NULL, txt, 2, kCFAllocatorNull);
		// find a font that contains it
		font2 = CTFontCreateForString(font2, str, CFRangeMake(0,2));
		must_release = true;
		CFRelease(str);
		b = CTFontGetGlyphsForCharacters(font2, txt, glyphs, 2);
	}
	if (b) CTFontGetAdvancesForGlyphs(font2, kCTFontHorizontalOrientation, glyphs, &a, 1);
	else a.width = fl_fontsize->q_width;
	if(must_release) CFRelease(font2);
	return a.width;
}

static CGFloat variation_selector_width(CFStringRef str16, Fl_Font_Descriptor *fl_fontsize)
{
	CGFloat retval;
	CFDictionarySetValue(attributes, kCTFontAttributeName, fl_fontsize->fontref);
	CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, str16, attributes);
	CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
	CFRelease(mastr);
	retval = CTLineGetOffsetForStringIndex(ctline, 2, NULL);
	CFRelease(ctline);
	return retval;
}
#endif

static double fl_mac_width(const UniChar* txt, int n, Fl_Font_Descriptor *fl_fontsize)
{
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
		double retval = 0;
		UniChar uni;
		int i;
		for (i = 0; i < n; i++) { // loop over txt
			uni = txt[i];
			if (uni >= 0xD800 && uni <= 0xDBFF) { // handles the surrogate range
				retval += surrogate_width(&txt[i], fl_fontsize);
				i++; // because a pair of UniChar's represent a single character
				continue;
			}
			if (i+1 < n && txt[i+1] >= 0xFE00 && txt[i+1] <= 0xFE0F) { // handles variation selectors
				CFStringRef substr = CFStringCreateWithCharacters(NULL, txt + i, 2);
				retval += variation_selector_width(substr, fl_fontsize);
				CFRelease(substr);
				i++;
				continue;
			}
			const int block = 0x10000 / (sizeof(fl_fontsize->width)/sizeof(float*)); // block size
			// r: index of the character block containing uni
			unsigned int r = uni >> 7; // change 7 if sizeof(width) is changed
			if (!fl_fontsize->width[r]) { // this character block has not been hit yet
				//fprintf(stderr,"r=%d size=%d name=%s\n",r,fl_fontsize->size,fl_fonts[fl_font()].name);
				// allocate memory to hold width of each character in the block
				fl_fontsize->width[r] = (float*) malloc(sizeof(float) * block);
				UniChar ii = r * block;
				CGSize advance_size;
				CGGlyph glyph;
				for (int j = 0; j < block; j++) { // loop over the block
					// ii spans all characters of this block
					bool b = CTFontGetGlyphsForCharacters(fl_fontsize->fontref, &ii, &glyph, 1);
					if (b)
						CTFontGetAdvancesForGlyphs(fl_fontsize->fontref, kCTFontHorizontalOrientation, &glyph, &advance_size, 1);
					else
						advance_size.width = -1e9; // calculate this later
					// the width of one character of this block of characters
					fl_fontsize->width[r][j] = advance_size.width;
					ii++;
				}
			}
			// sum the widths of all characters of txt
			double wdt = fl_fontsize->width[r][uni & (block-1)];
			if (wdt == -1e9) {
				CGSize advance_size;
				CGGlyph glyph;
				CTFontRef font2 = fl_fontsize->fontref;
				bool must_release = false;
				bool b = CTFontGetGlyphsForCharacters(font2, &uni, &glyph, 1);
				if (!b) { // the current font doesn't contain this char
					CFStringRef str = CFStringCreateWithCharactersNoCopy(NULL, &uni, 1, kCFAllocatorNull);
					// find a font that contains it
					font2 = CTFontCreateForString(font2, str, CFRangeMake(0,1));
					must_release = true;
					CFRelease(str);
					b = CTFontGetGlyphsForCharacters(font2, &uni, &glyph, 1);
				}
				if (b) CTFontGetAdvancesForGlyphs(font2, kCTFontHorizontalOrientation, &glyph, &advance_size, 1);
				else advance_size.width = 0.;
				// the width of the 'uni' character
				wdt = fl_fontsize->width[r][uni & (block-1)] = advance_size.width;
				if (must_release) CFRelease(font2);
			}
			retval += wdt;
		}
		return retval;
	} else {
#endif
#if HAS_ATSU
		OSStatus err;
		Fixed bBefore, bAfter, bAscent, bDescent;
		ATSUTextLayout layout;
		ByteCount iSize;
		ATSUAttributeTag iTag;
		ATSUAttributeValuePtr iValuePtr;

		// Here's my ATSU text measuring attempt... This seems to do the Right Thing
		// now collect our ATSU resources and measure our text string
		layout = fl_fontsize->layout;
		// activate the current GC
		iSize = sizeof(CGContextRef);
		iTag = kATSUCGContextTag;
		iValuePtr = &fl_gc;
		ATSUSetLayoutControls(layout, 1, &iTag, &iSize, &iValuePtr);
		// now measure the bounding box
		err = ATSUSetTextPointerLocation(layout, txt, kATSUFromTextBeginning, n, n);
		err = ATSUGetUnjustifiedBounds(layout, kATSUFromTextBeginning, n, &bBefore, &bAfter, &bAscent, &bDescent);
		// If err is OK then return length, else return 0. Or something...
		int len = FixedToInt(bAfter);
		return len;
#endif
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	}
#endif
	return 0;
}

double Fl_Quartz_Graphics_Driver::width(const char* txt, int n)
{
	int wc_len = n;
	UniChar *uniStr = mac_Utf8_to_Utf16(txt, n, &wc_len);
	if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
	return fl_mac_width(uniStr, wc_len, font_descriptor());
}

double Fl_Quartz_Graphics_Driver::width(unsigned int wc)
{
	if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);

	UniChar utf16[3];
	int l = 1;
	if (wc <= 0xFFFF) {
		*utf16 = wc;
	} else {
//    char buf[4];
//    l = fl_utf8encode(wc, buf);
//    l = (int)fl_utf8toUtf16(buf, l, utf16, 3);
		l = (int)fl_ucs_to_Utf16(wc, utf16, 3);
	}
	return fl_mac_width(utf16, l, font_descriptor());
}

// text extent calculation
void Fl_Quartz_Graphics_Driver::text_extents(const char *str8, int n, int &dx, int &dy, int &w, int &h)
{
	if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
	Fl_Font_Descriptor *fl_fontsize = font_descriptor();
	UniChar *txt = mac_Utf8_to_Utf16(str8, n, &n);
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
		CFStringRef str16 = CFStringCreateWithCharactersNoCopy(NULL, txt, n,  kCFAllocatorNull);
		CFDictionarySetValue (attributes, kCTFontAttributeName, fl_fontsize->fontref);
		CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, str16, attributes);
		CFRelease(str16);
		CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
		CFRelease(mastr);
		CGContextSetTextPosition(fl_gc, 0, 0);
		CGContextSetShouldAntialias(fl_gc, true);
		CGRect rect = CTLineGetImageBounds(ctline, fl_gc);
		CGContextSetShouldAntialias(fl_gc, false);
		CFRelease(ctline);
		dx = floor(rect.origin.x + 0.5);
		dy = floor(- rect.origin.y - rect.size.height + 0.5);
		w = rect.size.width + 0.5;
		h = rect.size.height + 0.5;
	} else {
#endif
#if HAS_ATSU
		OSStatus err;
		ATSUTextLayout layout;
		ByteCount iSize;
		ATSUAttributeTag iTag;
		ATSUAttributeValuePtr iValuePtr;

// Here's my ATSU text measuring attempt... This seems to do the Right Thing
		// now collect our ATSU resources and measure our text string
		layout = fl_fontsize->layout;
		// activate the current GC
		iSize = sizeof(CGContextRef);
		iTag = kATSUCGContextTag;
		iValuePtr = &fl_gc;
		ATSUSetLayoutControls(layout, 1, &iTag, &iSize, &iValuePtr);
		// now measure the bounding box
		err = ATSUSetTextPointerLocation(layout, txt, kATSUFromTextBeginning, n, n);
		Rect bbox;
		err = ATSUMeasureTextImage(layout, kATSUFromTextBeginning, n, 0, 0, &bbox);
		w = bbox.right - bbox.left;
		h = bbox.bottom - bbox.top;
		dx = bbox.left;
		dy = -bbox.bottom;
//printf("r: %d l: %d t: %d b: %d w: %d h: %d\n", bbox.right, bbox.left, bbox.top, bbox.bottom, w, h);
#endif
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	}
#endif
	return;
} // fl_text_extents

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
static CGColorRef flcolortocgcolor(Fl_Color i)
{
	uchar r, g, b;
	Fl::get_color(i, r, g, b);
	CGFloat components[4] = {r/255.0f, g/255.0f, b/255.0f, 1.};
	static CGColorSpaceRef cspace = NULL;
	if (cspace == NULL) {
		cspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
	}
	return CGColorCreate(cspace, components);
}
#endif

static void fl_mac_draw(const char *str, int n, float x, float y, Fl_Graphics_Driver *driver)
{
	// convert to UTF-16 first
	UniChar *uniStr = mac_Utf8_to_Utf16(str, n, &n);
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
		CFMutableStringRef str16 = CFStringCreateMutableWithExternalCharactersNoCopy(NULL, uniStr, n,  n, kCFAllocatorNull);
		if (str16 == NULL) return; // shd not happen
		CGColorRef color = flcolortocgcolor(driver->color());
		CFDictionarySetValue (attributes, kCTFontAttributeName, driver->font_descriptor()->fontref);
		CFDictionarySetValue (attributes, kCTForegroundColorAttributeName, color);
		CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, str16, attributes);
		CFRelease(str16);
		CFRelease(color);
		CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
		CFRelease(mastr);
		CGContextSetTextMatrix(fl_gc, font_mx);
		CGContextSetTextPosition(fl_gc, x, y);
		CGContextSetShouldAntialias(fl_gc, true);
		CTLineDraw(ctline, fl_gc);
		CGContextSetShouldAntialias(fl_gc, false);
		CFRelease(ctline);
	} else {
#endif
#if HAS_ATSU
		OSStatus err;
		// now collect our ATSU resources
		ATSUTextLayout layout = driver->font_descriptor()->layout;

		ByteCount iSize = sizeof(CGContextRef);
		ATSUAttributeTag iTag = kATSUCGContextTag;
		ATSUAttributeValuePtr iValuePtr=&fl_gc;
		ATSUSetLayoutControls(layout, 1, &iTag, &iSize, &iValuePtr);

		err = ATSUSetTextPointerLocation(layout, uniStr, kATSUFromTextBeginning, n, n);
		CGContextSetShouldAntialias(fl_gc, true);
		err = ATSUDrawText(layout, kATSUFromTextBeginning, n, FloatToFixed(x), FloatToFixed(y));
		CGContextSetShouldAntialias(fl_gc, false);
#endif
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	}
#endif
}

void Fl_Quartz_Graphics_Driver::draw(const char *str, int n, float x, float y)
{
	// avoid a crash if no font has been selected by user yet !
	if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
	fl_mac_draw(str, n, x, y, this);
}

void Fl_Quartz_Graphics_Driver::draw(const char* str, int n, int x, int y)
{
	// avoid a crash if no font has been selected by user yet !
	if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
	fl_mac_draw(str, n, (float)x-0.0f, (float)y+0.5f, this);
}

void Fl_Quartz_Graphics_Driver::draw(int angle, const char *str, int n, int x, int y)
{
	CGContextSaveGState(fl_gc);
	CGContextTranslateCTM(fl_gc, x, y);
	CGContextRotateCTM(fl_gc, - angle*(M_PI/180) );
	draw(str, n, 0, 0);
	CGContextRestoreGState(fl_gc);
}

void Fl_Quartz_Graphics_Driver::rtl_draw(const char* c, int n, int x, int y)
{
	int dx, dy, w, h;
	text_extents(c, n, dx, dy, w, h);
	draw(c, n, x - w - dx, y);
}

#endif
//
// End of "$Id: fl_font_mac.cxx 10193 2014-06-14 11:06:42Z manolo $".
//
